package com.weipu.common.facade.impl;

import java.io.IOException;
import java.net.SocketTimeoutException;
import java.net.UnknownHostException;

import org.apache.http.conn.ConnectTimeoutException;
import org.json.JSONException;
import org.json.JSONObject;

import android.text.TextUtils;
import android.util.Log;

import com.weipu.common.DXApplication;
import com.weipu.common.constants.Constant;
import com.weipu.common.constants.Constant.HttpMethod;
import com.weipu.common.constants.ServerConstant;
import com.weipu.common.facade.exception.DxException;
import com.weipu.common.facade.model.Parmars;
import com.weipu.common.okhttp.JsonUtils;
import com.weipu.common.okhttp.OkHttpHelper;
import com.weipu.common.util.JsonFormat;
import com.weipu.common.util.Logger;
import com.weipu.common.util.NetWorkUtil;
import com.weipu.common.util.StringUtil;

/**
 * 网络请求接口实现类的基类
 * @author huangfei
 *
 */
public class BaseServiceProviderImpl {
	/**
	 * 对数据进行异常捕获
	 * 
	 * @param result
	 * @return
	 * @throws DxException
	 *             [参数说明]
	 * @return JSONObject [返回类型说明]
	 * @exception throws [违例类型] [违例说明]
	 * @see [类、类#方法、类#成员]
	 */
	public JSONObject returnResult(String result) throws DxException {
		JSONObject json = null;
		if (null == result) {
			return null;
		}
		try {
			json = new JSONObject(result);
		} catch (JSONException e) {
			throw new DxException(
					ServerConstant.ReturnCode.STATUS_INTENAL_ERROR);
		}
		String status = json.optString(Constant.JSON_STATUS);
		// 请求到的数据无效
		if (null == status) {
			throw new DxException(
					ServerConstant.ReturnCode.STATUS_INTENAL_ERROR);
		}
		// 向外抛出异常
		if (!"0".equals(status)) {
			throw new DxException(status);
		}
		return json;
	}

	/**
	 * 执行网络请求
	 * 
	 * @param requestUrl
	 *            请求URL
	 * @param method
	 *            请求方法
	 * @param params
	 *            请求参数
	 * @param isNeedCurrencyCode
	 *            是否需要携带货币
	 * @param currencyCode
	 *            货币符号
	 * @return
	 * @throws DxException
	 */
	private JSONObject requestHttp(String requestUrl, HttpMethod method,
			Object params, boolean isNeedCurrencyCode, String currencyCode)
			throws DxException {
		Log.i("Result", "requestMethod: "+method+"   requestUrl: "+requestUrl);
		JSONObject jsonObject = null;
		String responseStr = null;
		String requestCurrencyCode = null;
		//如果需要传递货币，首先判断是否为空 为空就读取本地保存的当前货币符号
		if (isNeedCurrencyCode) {
			if (TextUtils.isEmpty(currencyCode)) {
				requestCurrencyCode = StringUtil.getConfig(
						ServerConstant.Parameter.PARAMETER_NAME_CURRENCYCODE,
						"USD");
			} else {
				requestCurrencyCode = currencyCode;
			}
		}
		OkHttpHelper okHttpHelper = OkHttpHelper.getOkHttpHelperInstance();
		try {
			switch (method) {
			case GET:
				responseStr = okHttpHelper.syncGetRequest(requestUrl,
						requestCurrencyCode);
				break;
			case POST:
				
				responseStr = okHttpHelper.syncPostRequest(requestUrl, params,
						requestCurrencyCode);
				
				break;
			case PUT:
				responseStr = okHttpHelper.syncPutRequest(requestUrl, params,
						requestCurrencyCode);
				break;
			case DELETE:

				break;

			default:
				break;
			}
			jsonObject = returnResult(responseStr);
			return jsonObject;
		} catch (IOException e) {
			Log.i("Result", "IOException "+e);
			// 链接超时
			if (e.getCause() instanceof SocketTimeoutException
					|| e.getCause() instanceof ConnectTimeoutException) {
				throw new DxException(
						ServerConstant.ReturnCode.VALIDATOR_CONNECT_TIMEOUT);
			} else if (e.getCause() instanceof UnknownHostException) {
				throw new DxException(
						ServerConstant.ReturnCode.CLIENT_NET_UN_AVAILABLE);
			} else {
				if (!NetWorkUtil.isNetworkAvailable(DXApplication.getContext())) {
					throw new DxException(
							ServerConstant.ReturnCode.CLIENT_NET_UN_AVAILABLE);
				} else {
					throw new DxException(
							ServerConstant.ReturnCode.VALIDATOR_UNKONW_ERROR);
				}
			}
		}
	}

	/**
	 * 同步的Http Get请求 获取该请求地址对应的Data数据
	 * @param requestUrl 请求地址
	 * @param currencyCode 货币符号  如果使用本地读取的可以传空值
	 * @return 返回该请求数据中对应的Data数据的JSONObeject对象
	 * @throws DxException
	 */
	protected JSONObject requestHttpGetData(String requestUrl, String currencyCode)
			throws DxException {
		JSONObject data = null;
		JSONObject json = requestHttp(requestUrl, HttpMethod.GET, null, true,
				currencyCode);
		if (null != json) {
			data = json.optJSONObject(Constant.JSON_DATA);
		}
		return data;
	}

	/**
	 * 同步的Http Get请求 获取该条链接对应的Data数据
	 * @param requestUrl 请求地址
	 * @return 返回该请求数据中对应的Data数据的JSONObeject对象
	 * @throws DxException
	 */
	protected JSONObject requestHttpGetData(String requestUrl) throws DxException {
		JSONObject data = null;
		JSONObject json = requestHttp(requestUrl, HttpMethod.GET, null, false,
				"");
		if (null != json) {
			data = json.optJSONObject(Constant.JSON_DATA);
		}
		return data;
	}

	/**
	 * 同步的Http Get请求 通过请求头获取该条链接对应的Data数据
	 * @param requestUrl 请求地址
	 * @param headName 请求头名
	 * @param headValue 请求头的值
	 * @return 返回该请求数据中对应的Data数据的JSONObeject对象
	 * @throws DxException
	 */
	protected JSONObject requestHttpGetDataByHeader(String requestUrl,String headName,String headValue) throws DxException {
		JSONObject data = null;
		OkHttpHelper okHttpHelper = OkHttpHelper.getOkHttpHelperInstance();

		try {
			String resultStr = okHttpHelper.syncGetRequestByHeader(requestUrl, "",headName, headValue);
			JSONObject json = returnResult(resultStr);
			if (null != json) {
				data = json.optJSONObject(Constant.JSON_DATA);
			}
			return data;

		} catch (IOException e) {
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * 同步的Http Get请求 获取该请求地址对应的所有数据
	 * @param requestUrl 请求Url
	 * @param currencyCode 货币符号
	 * @return 返回请求地址对应的所有数据的JSONObeject对象
	 * @throws DxException
	 */
	protected JSONObject requestHttpGetAll(String requestUrl,
			String currencyCode) throws DxException {
		return requestHttp(requestUrl, HttpMethod.GET, null, true, currencyCode);
	}

	/**
	 * 同步的Http Get请求 获取该请求地址对应的所有数据
	 * 
	 * @param requestUrl
	 * @return 返回请求地址对应的所有数据的JSONObeject对象
	 * @throws DxException
	 */
	protected JSONObject requestHttpGetAll(String requestUrl)
			throws DxException {
		return requestHttp(requestUrl, HttpMethod.GET, null, false, "");
	}

	/**
	 * get请求，获取JSONObject对象
	 * @param url 请求的地址
	 * @param parmars 请求的参数
	 * @return
	 */
	protected String getRequestByParams(String url, Parmars parmars) {
		OkHttpHelper helper = OkHttpHelper.getOkHttpHelperInstance();
		try {
			String result = helper.syncGetRequestByParams(url, parmars);
			returnResult(result);
			return result;
		} catch (IOException e) {
			e.printStackTrace();
		} catch (DxException e) {
			e.printStackTrace();
		}
		return null;
	}


	/**
	 * 同步的 Http Post方法 获取请求地址对应的Data数据
	 * @param requestUrl 请求Url
	 * @param params 请求参数
	 * @param currencyCode 货币
	 * @return 返回请求地址对应的Data数据的JSONObeject对象
	 * @throws DxException
	 */
	protected JSONObject requestHttpPostData(String requestUrl, Object params,
			String currencyCode) throws DxException {
		JSONObject data = null;
		JSONObject json = requestHttp(requestUrl, HttpMethod.POST, params, true,
				currencyCode);
		if (null != json) {
			data = json.optJSONObject(Constant.JSON_DATA);
		}
		return data;
	}

	/**
	 * 同步的Http Post请求 获取请求地址对应的Data数据
	 * @param requestUrl 请求URL
	 * @param params 请求参数
	 * @return 请求地址对应的Data数据的JSONObeject对象
	 * @throws DxException
	 */
	protected JSONObject requestHttpPostData(String requestUrl, Object params)
			throws DxException {
		JSONObject data = null;
		JSONObject json = requestHttp(requestUrl, HttpMethod.POST, params, false,
				"");
		if (null != json) {
			data = json.optJSONObject(Constant.JSON_DATA);
		}
		return data;
	}

	/**
	 * 同步的Http Post请求 获取请求地址对应的所有数据
	 * @param requestUrl 请求Url
	 * @param params 请求参数
	 * @param currencyCode 请求货币
	 * @return 请求地址对应的所有数据的JSONObeject对象
	 * @throws DxException
	 */
	protected JSONObject requestHttpPostAll(String requestUrl,
			Object params, String currencyCode) throws DxException {

		return requestHttp(requestUrl, HttpMethod.POST, params, true,
				currencyCode);
	}

	/**
	 * 同步的Http Post请求 获取请求地址对应的所有数据
	 * @param requestUrl 请求Url
	 * @param params 请求参数
	 * @return 请求地址对应的所有数据的JSONObeject对象
	 * @throws DxException
	 */
	protected JSONObject requestHttpPostAll(String requestUrl,
			Object params) throws DxException {

		return requestHttp(requestUrl, HttpMethod.POST, params, false, "");
	}

    /**
     * 同步的Http Put请求  获取请求地址对应的Data数据
     * @param requestUrl 请求地址
     * @param params 请求参数
     * @param currencyCode 请求货币
     * @return 请求地址对应的Data数据的JSONObeject对象
     * @throws DxException
     */
	protected JSONObject requestHttpPutData(String requestUrl, Object params,
			String currencyCode) throws DxException {
		JSONObject data = null;

		JSONObject json = requestHttp(requestUrl, HttpMethod.PUT, params, true,
				currencyCode);
		if (null != json) {
			data = json.optJSONObject(Constant.JSON_DATA);
		}

		return data;
	}
	
	/**
     * 同步的Http Put请求  获取请求地址对应的Data数据
     * @param requestUrl 请求地址
     * @param params 请求参数
     * @return 请求地址对应的Data数据的JSONObeject对象
     * @throws DxException
     */
	protected JSONObject requestHttpPutData(String requestUrl, Object params) throws DxException {
		JSONObject data = null;

		JSONObject json = requestHttp(requestUrl, HttpMethod.PUT, params, false,
				"");
		if (null != json) {
			data = json.optJSONObject(Constant.JSON_DATA);
		}
		return data;
	}


	/**
     * 同步的Http Put请求  获取请求地址对应的所有数据
     * @param requestUrl 请求地址
     * @param params 请求参数
     * @param currencyCode 请求货币
     * @return 请求地址对应的所有数据的JSONObeject对象
     * @throws DxException
     */
	protected JSONObject requestHttpPutAll(String requestUrl,
			Object params, String currencyCode) throws DxException {
		return  requestHttp(requestUrl, HttpMethod.PUT, params, true,
				currencyCode);
	}
	/**
     * 同步的Http Put请求  获取请求地址对应的所有数据
     * @param requestUrl 请求地址
     * @param params 请求参数
     * @return 请求地址对应的所有数据的JSONObeject对象
     * @throws DxException
     */
	protected JSONObject requestHttpPutAll(String requestUrl,
			Object params) throws DxException {
		return  requestHttp(requestUrl, HttpMethod.PUT, params, false,
				"");
	}

	/**
     * 同步的Http Delete请求  获取请求地址对应的所有数据
     * @param requestUrl 请求地址
     * @param params 请求参数
     * @param currencyCode 请求货币
     * @return 请求地址对应的所有数据的JSONObeject对象
     * @throws DxException
     * TODO 需要实现具体操作
     */
	protected JSONObject requestHttpDelete(String Url, String currencyCode)
			throws DxException {
		JSONObject data = null;
		return data;
	}
}
